home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / gfx / misc / gnuplot-src.lha / gnuplot-3.7.1src / gnuplot-3.7.1.lha / gnuplot-3.7.1 / graph3d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  56.9 KB  |  1,977 lines
  1. #ifndef lint, place, &x, &y)Sid = "$Id: graph3d.c,v 1.13.2.4 1999/10/19 13:31:49 lhecking Exp $";
  2. #endif
  3.  
  4. /* GNUPLOT - graph3d.c */
  5.  
  6. /*[
  7.  * Copyright 1986 - 1993, 1998   Thomas Williams, Colin Kelley
  8.  *
  9.  * Permission to use, copy, and distribute this software and its
  10.  * documentation for any purpose with or without fee is hereby granted,
  11.  * provided that the above copyright notice appear in all copies and
  12.  * that both that copyright notice and this permission notice appear
  13.  * in supporting documentation.
  14.  *
  15.  * Permission to modify the software is granted, but not the right to
  16.  * distribute the complete modified source code.  Modifications are to
  17.  * be distributed as patches to the released version.  Permission to
  18.  * distribute binaries produced by compiling modified sources is granted,
  19.  * provided you
  20.  *   1. distribute the corresponding source modifications from the
  21.  *    released version in the form of a patch file along with the binaries,
  22.  *   2. add special version identification to distinguish your version
  23.  *    in addition to the base release version number,
  24.  *   3. provide your name and address as the primary contact for the
  25.  *    support of your modified version, and
  26.  *   4. retain our contact information in regard to use of the base
  27.  *    software.
  28.  * Permission to distribute the released version of the source code along
  29.  * with corresponding source modifications in the form of a patch file is
  30.  * granted with same provisions 2 through 4 for binary distributions.
  31.  *
  32.  * This software is provided "as is" without express or implied warranty
  33.  * to the extent permitted by applicable law.
  34. ]*/
  35.  
  36.  
  37. /*
  38.  * AUTHORS
  39.  *
  40.  *   Original Software:
  41.  *       Gershon Elber and many others.
  42.  *
  43.  * 19 September 1992  Lawrence Crowl  (crowl@cs.orst.edu)
  44.  * Added user-specified bases for log scaling.
  45.  *
  46.  * 3.6 - split graph3d.c into graph3d.c (graph),
  47.  *                            util3d.c (intersections, etc)
  48.  *                            hidden3d.c (hidden-line removal code)
  49.  *
  50.  */
  51.  
  52. #include "plot.h"
  53. #include "setshow.h"
  54.  
  55. static int p_height;
  56. static int p_width;        /* pointsize * t->h_tic */
  57. static int key_entry_height;    /* bigger of t->v_size, pointsize*t->v_tick */
  58.  
  59. int suppressMove = 0;        /* to prevent moveto while drawing contours */
  60.  
  61. /*
  62.  * hidden_line_type_above, hidden_line_type_below - controls type of lines
  63.  *   for above and below parts of the surface.
  64.  * hidden_no_update - if TRUE lines will be hidden line removed but they
  65.  *   are not assumed to be part of the surface (i.e. grid) and therefore
  66.  *   do not influence the hidings.
  67.  * hidden_active - TRUE if hidden lines are to be removed.
  68.  */
  69. int hidden_active = FALSE;
  70. int hidden_no_update;        /* HBB 980324: made this visible despite LITE */
  71.  
  72. /* LITE defines a restricted memory version for MS-DOS, which doesn't
  73.  * use the routines in hidden3d.c
  74.  */
  75.  
  76. #ifndef LITE
  77. int hidden_line_type_above, hidden_line_type_below;
  78. #endif /* LITE */
  79.  
  80.  
  81. static double LogScale __PROTO((double coord, TBOOLEAN is_log,
  82.                 double log_base_log, char *what, char *axis));
  83. static void plot3d_impulses __PROTO((struct surface_points * plot));
  84. static void plot3d_lines __PROTO((struct surface_points * plot));
  85. static void plot3d_points __PROTO((struct surface_points * plot));
  86. static void plot3d_dots __PROTO((struct surface_points * plot));
  87. static void cntr3d_impulses __PROTO((struct gnuplot_contours * cntr,
  88.                      struct surface_points * plot));
  89. static void cntr3d_lines __PROTO((struct gnuplot_contours * cntr));
  90. static void cntr3d_points __PROTO((struct gnuplot_contours * cntr,
  91.                    struct surface_points * plot));
  92. static void cntr3d_dots __PROTO((struct gnuplot_contours * cntr));
  93. static void check_corner_height __PROTO((struct coordinate GPHUGE * point,
  94.                      double height[2][2], double depth[2][2]));
  95. static void draw_bottom_grid __PROTO((struct surface_points * plot,
  96.                       int plot_count));
  97. static void xtick_callback __PROTO((int axis, double place, char *text,
  98.                     struct lp_style_type grid));
  99. static void ytick_callback __PROTO((int axis, double place, char *text,
  100.                     struct lp_style_type grid));
  101. static void ztick_callback __PROTO((int axis, double place, char *text,
  102.                     struct lp_style_type grid));
  103. static void setlinestyle __PROTO((struct lp_style_type style));
  104.  
  105. static void boundary3d __PROTO((int scaling, struct surface_points * plots,
  106.                 int count));
  107. #if 0                /* not used */
  108. static double dbl_raise __PROTO((double x, int y));
  109. #endif
  110. static void map_position __PROTO((struct position * pos, unsigned int *x,
  111.                   unsigned int *y, char *what));
  112.  
  113. /* put entries in the key */
  114. static void key_sample_line __PROTO((int xl, int yl));
  115. static void key_sample_point __PROTO((int xl, int yl, int pointtype));
  116. static void key_text __PROTO((int xl, int yl, char *text));
  117.  
  118.  
  119. #if defined(sun386) || defined(AMIGA_SC_6_1)
  120. static double CheckLog __PROTO((TBOOLEAN is_log, double base_log, double x));
  121. #endif
  122.  
  123. /*
  124.  * The Amiga SAS/C 6.2 compiler moans about macro envocations causing
  125.  * multiple calls to functions. I converted these macros to inline
  126.  * functions coping with the problem without loosing speed.
  127.  * (MGR, 1993)
  128.  */
  129. #ifdef AMIGA_SC_6_1
  130. GP_INLINE static TBOOLEAN i_inrange(int z, int min, int max)
  131. {
  132.     return ((min < max) ? ((z >= min) && (z <= max)) : ((z >= max) && (z <= min)));
  133. }
  134.  
  135. GP_INLINE static double f_max(double a, double b)
  136. {
  137.     return (max(a, b));
  138. }
  139.  
  140. GP_INLINE static double f_min(double a, double b)
  141. {
  142.     return (min(a, b));
  143. }
  144.  
  145. #else
  146. # define f_max(a,b) GPMAX((a),(b))
  147. # define f_min(a,b) GPMIN((a),(b))
  148. # define i_inrange(z,a,b) inrange((z),(a),(b))
  149. #endif
  150.  
  151. #define apx_eq(x,y) (fabs(x-y) < 0.001)
  152. #define ABS(x) ((x) >= 0 ? (x) : -(x))
  153. #define SQR(x) ((x) * (x))
  154.  
  155. /* Define the boundary of the plot
  156.  * These are computed at each call to do_plot, and are constant over
  157.  * the period of one do_plot. They actually only change when the term
  158.  * type changes and when the 'set size' factors change. 
  159.  */
  160.  
  161. /* in order to allow graphic.c to use clip_draw_line, we must
  162.  * share xleft, xright, ybot, ytop with graphics.c
  163.  */
  164. extern int xleft, xright, ybot, ytop;
  165.  
  166. int xmiddle, ymiddle, xscaler, yscaler;
  167. static int ptitl_cnt;
  168. static int max_ptitl_len;
  169. static int titlelin;
  170. static int key_sample_width, key_rows, key_cols, key_col_wth, yl_ref;
  171. static int ktitle_lines = 0;
  172.  
  173.  
  174. /* Boundary and scale factors, in user coordinates */
  175. /* x_min3d, x_max3d, y_min3d, y_max3d, z_min3d, z_max3d are local to this
  176.  * file and are not the same as variables of the same names in other files
  177.  */
  178. /*static double x_min3d, x_max3d, y_min3d, y_max3d, z_min3d, z_max3d; */
  179. /* sizes are now set in min_array[], max_array[] from plot.c */
  180. extern double min_array[], max_array[];
  181. extern int auto_array[], log_array[];
  182. extern double base_array[], log_base_array[];
  183.  
  184. /* for convenience while converting to use these arrays */
  185. #define x_min3d min_array[FIRST_X_AXIS]
  186. #define x_max3d max_array[FIRST_X_AXIS]
  187. #define y_min3d min_array[FIRST_Y_AXIS]
  188. #define y_max3d max_array[FIRST_Y_AXIS]
  189. #define z_min3d min_array[FIRST_Z_AXIS]
  190. #define z_max3d max_array[FIRST_Z_AXIS]
  191.  
  192. /* There are several z's to take into account - I hope I get these
  193.  * right !
  194.  *
  195.  * ceiling_z is the highest z in use
  196.  * floor_z   is the lowest z in use
  197.  * base_z is the z of the base
  198.  * min3d_z is the lowest z of the graph area
  199.  * max3d_z is the highest z of the graph area
  200.  *
  201.  * ceiling_z is either max3d_z or base_z, and similarly for floor_z
  202.  * There should be no part of graph drawn outside
  203.  * min3d_z:max3d_z  - apart from arrows, perhaps
  204.  */
  205.  
  206. double ceiling_z, floor_z, base_z;
  207.  
  208. /* and some bodges while making the change */
  209. #define min3d_z min_array[FIRST_Z_AXIS]
  210. #define max3d_z max_array[FIRST_Z_AXIS]
  211.  
  212.  
  213. double xscale3d, yscale3d, zscale3d;
  214.  
  215.  
  216. typedef double transform_matrix[4][4];
  217. transform_matrix trans_mat;
  218.  
  219. static double xaxis_y, yaxis_x, zaxis_x, zaxis_y;
  220.  
  221. /* the co-ordinates of the back corner */
  222. static double back_x, back_y;
  223.  
  224. /* the penalty for convenience of using tic_gen to make callbacks
  225.  * to tick routines is that we cant pass parameters very easily.
  226.  * We communicate with the tick_callbacks using static variables
  227.  */
  228.  
  229. /* unit vector (terminal coords) */
  230. static double tic_unitx, tic_unity;
  231.  
  232. /* (DFK) Watch for cancellation error near zero on axes labels */
  233. #define SIGNIF (0.01)        /* less than one hundredth of a tic mark */
  234. #define CheckZero(x,tic) (fabs(x) < ((tic) * SIGNIF) ? 0.0 : (x))
  235. #define NearlyEqual(x,y,tic) (fabs((x)-(y)) < ((tic) * SIGNIF))
  236.  
  237. /* And the functions to map from user to terminal coordinates */
  238. #define map_x(x) (int)(x+0.5)    /* maps floating point x to screen */
  239. #define map_y(y) (int)(y+0.5)    /* same for y */
  240.  
  241. /* And the functions to map from user 3D space into normalized -1..1 */
  242. #define map_x3d(x) ((x-x_min3d)*xscale3d-1.0)
  243. #define map_y3d(y) ((y-y_min3d)*yscale3d-1.0)
  244. #define map_z3d(z) ((z-floor_z)*zscale3d-1.0)
  245.  
  246.  
  247.  
  248. /* Initialize the line style using the current device and set hidden styles
  249.  * to it as well if hidden line removal is enabled */
  250. static void setlinestyle(style)
  251. struct lp_style_type style;
  252. {
  253.     term_apply_lp_properties(&style);
  254.  
  255. #ifndef LITE
  256.     if (hidden3d) {
  257.     hidden_line_type_above = style.l_type;
  258.     hidden_line_type_below = style.l_type;
  259.     }
  260. #endif /* LITE */
  261. }
  262.  
  263. /* (DFK) For some reason, the Sun386i compiler screws up with the CheckLog 
  264.  * macro, so I write it as a function on that machine.
  265.  *
  266.  * Amiga SAS/C 6.2 thinks it will do too much work calling functions in
  267.  * macro arguments twice, thus I inline theese functions. (MGR, 1993)
  268.  */
  269. #if defined(sun386) || defined(AMIGA_SC_6_1)
  270. GP_INLINE static double CheckLog(is_log, base_log, x)
  271. TBOOLEAN is_log;
  272. double base_log;
  273. double x;
  274. {
  275.     if (is_log)
  276.     return (pow(base_log, x));
  277.     else
  278.     return (x);
  279. }
  280. #else
  281. /* (DFK) Use 10^x if logscale is in effect, else x */
  282. # define CheckLog(is_log, base_log, x) ((is_log) ? pow(base_log, (x)) : (x))
  283. #endif /* sun386 || SAS/C */
  284.  
  285. static double LogScale(coord, is_log, log_base_log, what, axis)
  286. double coord;            /* the value */
  287. TBOOLEAN is_log;        /* is this axis in logscale? */
  288. double log_base_log;        /* if so, the log of its base */
  289. char *what;            /* what is the coord for? */
  290. char *axis;            /* which axis is this for ("x" or "y")? */
  291. {
  292.     if (is_log) {
  293.     if (coord <= 0.0) {
  294.         char errbuf[100];    /* place to write error message */
  295.         (void) sprintf(errbuf, "%s has %s coord of %g; must be above 0 for log scale!",
  296.                what, axis, coord);
  297.         graph_error(errbuf);
  298.     } else
  299.         return (log(coord) / log_base_log);
  300.     }
  301.     return (coord);
  302. }
  303.  
  304. /* And the functions to map from user 3D space to terminal coordinates */
  305. void map3d_xy(x, y, z, xt, yt)
  306. double x, y, z;
  307. unsigned int *xt, *yt;
  308. {
  309.     int i, j;
  310.     double v[4], res[4], /* Homogeneous coords. vectors. */
  311.     w = trans_mat[3][3];
  312.  
  313.     v[0] = map_x3d(x);        /* Normalize object space to -1..1 */
  314.     v[1] = map_y3d(y);
  315.     v[2] = map_z3d(z);
  316.     v[3] = 1.0;
  317.  
  318.     for (i = 0; i < 2; i++) {    /* Dont use the third axes (z). */
  319.     res[i] = trans_mat[3][i];    /* Initiate it with the weight factor */
  320.     for (j = 0; j < 3; j++)
  321.         res[i] += v[j] * trans_mat[j][i];
  322.     }
  323.  
  324.     for (i = 0; i < 3; i++)
  325.     w += v[i] * trans_mat[i][3];
  326.     if (w == 0)
  327.     w = 1e-5;
  328.  
  329.     *xt = (unsigned int) ((res[0] * xscaler / w) + xmiddle);
  330.     *yt = (unsigned int) ((res[1] * yscaler / w) + ymiddle);
  331. }
  332.  
  333.  
  334.  
  335. /* And the functions to map from user 3D space to terminal z coordinate */
  336. int map3d_z(x, y, z)
  337. double x, y, z;
  338. {
  339.     int i, zt;
  340.     double v[4], res, /* Homogeneous coords. vectors. */
  341.     w = trans_mat[3][3];
  342.  
  343.     v[0] = map_x3d(x);        /* Normalize object space to -1..1 */
  344.     v[1] = map_y3d(y);
  345.     v[2] = map_z3d(z);
  346.     v[3] = 1.0;
  347.  
  348.     res = trans_mat[3][2];    /* Initiate it with the weight factor. */
  349.     for (i = 0; i < 3; i++)
  350.     res += v[i] * trans_mat[i][2];
  351.     if (w == 0)
  352.     w = 1e-5;
  353.     for (i = 0; i < 3; i++)
  354.     w += v[i] * trans_mat[i][3];
  355.     zt = ((int) (res * 16384 / w));
  356.     return zt;
  357. }
  358.  
  359. /* borders of plotting area */
  360. /* computed once on every call to do_plot */
  361. static void boundary3d(scaling, plots, count)
  362. TBOOLEAN scaling;        /* TRUE if terminal is doing the scaling */
  363. struct surface_points *plots;
  364. int count;
  365. {
  366.     register struct termentry *t = term;
  367.     int ytlen, i;
  368.  
  369.     titlelin = 0;
  370.  
  371.     p_height = pointsize * t->v_tic;
  372.     p_width = pointsize * t->h_tic;
  373.     if (key_swidth >= 0)
  374.     key_sample_width = key_swidth * (t->h_char) + pointsize * (t->h_tic);
  375.     else
  376.     key_sample_width = 0;
  377.     key_entry_height = pointsize * (t->v_tic) * 1.25 * key_vert_factor;
  378.     if (key_entry_height < (t->v_char)) {
  379.     /* is this reasonable ? */
  380.     key_entry_height = (t->v_char) * key_vert_factor;
  381.     }
  382.  
  383.     /* count max_len key and number keys (plot-titles and contour labels) with len > 0 */
  384.     max_ptitl_len = find_maxl_keys3d(plots, count, &ptitl_cnt);
  385.     if ((ytlen = label_width(key_title, &ktitle_lines)) > max_ptitl_len)
  386.     max_ptitl_len = ytlen;
  387.     key_col_wth = (max_ptitl_len + 4) * (t->h_char) + key_sample_width;
  388.  
  389.     /* luecken@udel.edu modifications
  390.        sizes the plot to take up more of available resolution */
  391.     if (lmargin >= 0)
  392.     xleft = (t->h_char) * lmargin;
  393.     else
  394.     xleft = (t->h_char) * 2 + (t->h_tic);
  395.     xright = (scaling ? 1 : xsize) * (t->xmax) - (t->h_char) * 2 - (t->h_tic);
  396.     key_rows = ptitl_cnt;
  397.     key_cols = 1;
  398.     if (key == -1 && key_vpos == TUNDER) {
  399.       if (ptitl_cnt > 0) {
  400.     /* calculate max no cols, limited by label-length */
  401.     key_cols = (int) (xright - xleft) / ((max_ptitl_len + 4) * (t->h_char) + key_sample_width);
  402.     /* HBB 991019: fix division by zero problem */
  403.     if (key_cols == 0)
  404.         key_cols = 1;
  405.     key_rows = (int) (ptitl_cnt / key_cols) + ((ptitl_cnt % key_cols) > 0);
  406.     /* now calculate actual no cols depending on no rows */
  407.     key_cols = (int) (ptitl_cnt / key_rows) + ((ptitl_cnt % key_rows) > 0);
  408.     key_col_wth = (int) (xright - xleft) / key_cols;
  409.     /* key_rows += ktitle_lines; - messes up key - div */
  410.       } else {
  411.     key_rows = key_cols = key_col_wth = 0;
  412.       }
  413.     }
  414.     /* this should also consider the view and number of lines in
  415.      * xformat || yformat || xlabel || ylabel */
  416.  
  417.     /* an absolute 1, with no terminal-dependent scaling ? */
  418.     ybot = (t->v_char) * 2.5 + 1;
  419.     if (key_rows && key_vpos == TUNDER)
  420.     ybot += key_rows * key_entry_height + ktitle_lines * t->v_char;
  421.  
  422.     if (strlen(title.text)) {
  423.     titlelin++;
  424.     for (i = 0; i < strlen(title.text); i++) {
  425.         if (title.text[i] == '\\')
  426.         titlelin++;
  427.     }
  428.     }
  429.     ytop = (scaling ? 1 : ysize) * (t->ymax) - (t->v_char) * (titlelin + 1.5) - 1;
  430.     if (key == -1 && key_vpos != TUNDER) {
  431.     /* calculate max no rows, limited be ytop-ybot */
  432.     i = (int) (ytop - ybot) / (t->v_char) - 1 - ktitle_lines;
  433.     if (ptitl_cnt > i) {
  434.         key_cols = (int) (ptitl_cnt / i) + ((ptitl_cnt % i) > 0);
  435.         /* now calculate actual no rows depending on no cols */
  436.         key_rows = (int) (ptitl_cnt / key_cols) + ((ptitl_cnt % key_cols) > 0);
  437.     }
  438.     key_rows += ktitle_lines;
  439.     }
  440.     if (key_hpos == TOUT) {
  441.     xright -= key_col_wth * (key_cols - 1) + key_col_wth - 2 * (t->h_char);
  442.     }
  443.     xleft += t->xmax * xoffset;
  444.     xright += t->xmax * xoffset;
  445.     ytop += t->ymax * yoffset;
  446.     ybot += t->ymax * yoffset;
  447.     xmiddle = (xright + xleft) / 2;
  448.     ymiddle = (ytop + ybot) / 2;
  449.     /* HBB 980308: sigh... another 16bit glitch: on term's with more than
  450.      * 8000 pixels in either direction, these calculations produce garbage
  451.      * results if done in (16bit) ints */
  452.     xscaler = ((xright - xleft) * 4L) / 7L;              /* HBB: Magic number alert! */
  453.     yscaler = ((ytop - ybot) * 4L) / 7L;
  454.  
  455. }
  456.  
  457. #if 0
  458. /* not used ; anyway, should be done using bitshifts and squares,
  459.  * rather than iteratively
  460.  */
  461. static double dbl_raise(x, y)
  462. double x;
  463. int y;
  464. {
  465.     register int i = ABS(y);
  466.     double val = 1.0;
  467.     while (--i >= 0)
  468.     val *= x;
  469.     if (y < 0)
  470.     return (1.0 / val);
  471.     return (val);
  472. }
  473. #endif
  474.  
  475. /* we precalculate features of the key, to save lots of nested
  476.  * ifs in code - x,y = user supplied or computed position of key
  477.  * taken to be inner edge of a line sample
  478.  */
  479. static int key_sample_left;    /* offset from x for left of line sample */
  480. static int key_sample_right;    /* offset from x for right of line sample */
  481. static int key_point_offset;    /* offset from x for point sample */
  482. static int key_text_left;    /* offset from x for left-justified text */
  483. static int key_text_right;    /* offset from x for right-justified text */
  484. static int key_size_left;    /* distance from x to left edge of box */
  485. static int key_size_right;    /* distance from x to right edge of box */
  486.  
  487. void do_3dplot(plots, pcount)
  488. struct surface_points *plots;
  489. int pcount;            /* count of plots in linked list */
  490. {
  491.     struct termentry *t = term;
  492.     int surface;
  493.     struct surface_points *this_plot = NULL;
  494.     unsigned int xl, yl;
  495.     int linetypeOffset = 0;
  496.     /* double ztemp, temp; unused */
  497.     struct text_label *this_label;
  498.     struct arrow_def *this_arrow;
  499.     TBOOLEAN scaling;
  500.     transform_matrix mat;
  501.     int key_count;
  502.     char *s, *e;
  503.  
  504.     /* Initiate transformation matrix using the global view variables. */
  505.     mat_rot_z(surface_rot_z, trans_mat);
  506.     mat_rot_x(surface_rot_x, mat);
  507.     mat_mult(trans_mat, trans_mat, mat);
  508.     mat_scale(surface_scale / 2.0, surface_scale / 2.0, surface_scale / 2.0, mat);
  509.     mat_mult(trans_mat, trans_mat, mat);
  510.  
  511. #if 0
  512.     /* HBB 19990609: this is *not* the way to implement 'set view' <z_scale> */
  513.     /* modify min_z/max_z so it will zscale properly. */
  514.     ztemp = (z_max3d - z_min3d) / (2.0 * surface_zscale);
  515.     temp = (z_max3d + z_min3d) / 2.0;
  516.     z_min3d = temp - ztemp;
  517.     z_max3d = temp + ztemp;
  518. #endif /* 0 */
  519.  
  520.     /* The extrema need to be set even when a surface is not being
  521.      * drawn.   Without this, gnuplot used to assume that the X and
  522.      * Y axis started at zero.   -RKC
  523.      */
  524.  
  525.     if (polar)
  526.     graph_error("Cannot splot in polar coordinate system.");
  527.  
  528.     /* done in plot3d.c
  529.      *    if (z_min3d == VERYLARGE || z_max3d == -VERYLARGE ||
  530.      *      x_min3d == VERYLARGE || x_max3d == -VERYLARGE ||
  531.      *      y_min3d == VERYLARGE || y_max3d == -VERYLARGE)
  532.      *      graph_error("all points undefined!");
  533.      */
  534.  
  535.     /* If we are to draw the bottom grid make sure zmin is updated properly. */
  536.     if (xtics || ytics || work_grid.l_type) {
  537.     base_z = z_min3d - (z_max3d - z_min3d) * ticslevel;
  538.     if (ticslevel >= 0)
  539.         floor_z = base_z;
  540.     else
  541.         floor_z = z_min3d;
  542.  
  543.     if (ticslevel < -1)
  544.         ceiling_z = base_z;
  545.     else
  546.         ceiling_z = z_max3d;
  547.     } else {
  548.     floor_z = base_z = z_min3d;
  549.     ceiling_z = z_max3d;
  550.     }
  551.  
  552.     /*  see comment accompanying similar tests of x_min/x_max and y_min/y_max
  553.      *  in graphics.c:do_plot(), for history/rationale of these tests */
  554.     if (x_min3d == x_max3d)
  555.     graph_error("x_min3d should not equal x_max3d!");
  556.     if (y_min3d == y_max3d)
  557.     graph_error("y_min3d should not equal y_max3d!");
  558.     if (z_min3d == z_max3d)
  559.     graph_error("z_min3d should not equal z_max3d!");
  560.  
  561. #ifndef LITE
  562.     if (hidden3d) {
  563.     struct surface_points *plot;
  564.     int p = 0;
  565.     /* Verify data is hidden line removable - grid based. */
  566.     for (plot = plots; ++p <= pcount; plot = plot->next_sp) {
  567.         if (plot->plot_type == DATA3D && !plot->has_grid_topology) {
  568.         fprintf(stderr, "Notice: Cannot remove hidden lines from non grid data\n");
  569.         return;
  570.         }
  571.     }
  572.     }
  573. #endif /* not LITE */
  574.  
  575.     term_start_plot();
  576.  
  577.     screen_ok = FALSE;
  578.     scaling = (*t->scale) (xsize, ysize);
  579.  
  580.     /* now compute boundary for plot (xleft, xright, ytop, ybot) */
  581.     boundary3d(scaling, plots, pcount);
  582.  
  583.     /* SCALE FACTORS */
  584.     zscale3d = 2.0 / (ceiling_z - floor_z) * surface_zscale;
  585.     yscale3d = 2.0 / (y_max3d - y_min3d);
  586.     xscale3d = 2.0 / (x_max3d - x_min3d);
  587.  
  588.     term_apply_lp_properties(&border_lp);    /* border linetype */
  589.  
  590.     /* PLACE TITLE */
  591.     if (*title.text != 0) {
  592.     write_multiline((unsigned int) ((xleft + xright) / 2 + title.xoffset * t->h_char),
  593.             (unsigned int) (ytop + (titlelin + title.yoffset) * (t->h_char)),
  594.             title.text, CENTRE, JUST_TOP, 0, title.font);
  595.     }
  596.     /* PLACE TIMEDATE */
  597.     if (*timelabel.text) {
  598.     char str[MAX_LINE_LEN+1];
  599.     time_t now;
  600.     unsigned int x = t->v_char + timelabel.xoffset * t->h_char;
  601.     unsigned int y = timelabel_bottom ?
  602.     yoffset * ymax + (timelabel.yoffset + 1) * t->v_char :
  603.     ytop + (timelabel.yoffset - 1) * t->v_char;
  604.  
  605.     time(&now);
  606.     strftime(str, MAX_LINE_LEN, timelabel.text, localtime(&now));
  607.  
  608.     if (timelabel_rotate && (*t->text_angle) (1)) {
  609.         if (timelabel_bottom)
  610.         write_multiline(x, y, str, LEFT, JUST_TOP, 1, timelabel.font);
  611.         else
  612.         write_multiline(x, y, str, RIGHT, JUST_TOP, 1, timelabel.font);
  613.  
  614.         (*t->text_angle) (0);
  615.     } else {
  616.         if (timelabel_bottom)
  617.         write_multiline(x, y, str, LEFT, JUST_BOT, 0, timelabel.font);
  618.         else
  619.         write_multiline(x, y, str, LEFT, JUST_TOP, 0, timelabel.font);
  620.     }
  621.     }
  622.     /* PLACE LABELS */
  623.     for (this_label = first_label; this_label != NULL;
  624.      this_label = this_label->next) {
  625.     unsigned int x, y;
  626.  
  627.  
  628.     map_position(&this_label->place, &x, &y, "label");
  629.     if (this_label->rotate && (*t->text_angle) (1)) {
  630.         write_multiline(x, y, this_label->text, this_label->pos, CENTRE, 1, this_label->font);
  631.         (*t->text_angle) (0);
  632.     } else {
  633.         write_multiline(x, y, this_label->text, this_label->pos, CENTRE, 0, this_label->font);
  634.     }
  635.     }
  636.  
  637.     /* PLACE ARROWS */
  638.     for (this_arrow = first_arrow; this_arrow != NULL;
  639.      this_arrow = this_arrow->next) {
  640.     unsigned int sx, sy, ex, ey;
  641.  
  642.     map_position(&this_arrow->start, &sx, &sy, "arrow");
  643.     map_position(&this_arrow->end, &ex, &ey, "arrow");
  644.     term_apply_lp_properties(&(this_arrow->lp_properties));
  645.     (*t->arrow) (sx, sy, ex, ey, this_arrow->head);
  646.     }
  647.  
  648. #ifndef LITE
  649.     if (hidden3d && draw_surface) {
  650.     init_hidden_line_removal();
  651.     reset_hidden_line_removal();
  652.     hidden_active = TRUE;
  653.     }
  654. #endif /* not LITE */
  655.  
  656.     /* WORK OUT KEY SETTINGS AND DO KEY TITLE / BOX */
  657.  
  658.     if (key_reverse) {
  659.     key_sample_left = -key_sample_width;
  660.     key_sample_right = 0;
  661.     key_text_left = t->h_char;
  662.     key_text_right = (t->h_char) * (max_ptitl_len + 1);
  663.     key_size_right = (t->h_char) * (max_ptitl_len + 2 + key_width_fix);
  664.     key_size_left = (t->h_char) + key_sample_width;
  665.     } else {
  666.     key_sample_left = 0;
  667.     key_sample_right = key_sample_width;
  668.     key_text_left = -(int) ((t->h_char) * (max_ptitl_len + 1));
  669.     key_text_right = -(int) (t->h_char);
  670.     key_size_left = (t->h_char) * (max_ptitl_len + 2 + key_width_fix);
  671.     key_size_right = (t->h_char) + key_sample_width;
  672.     }
  673.     key_point_offset = (key_sample_left + key_sample_right) / 2;
  674.  
  675.     if (key == -1) {
  676.     if (key_vpos == TUNDER) {
  677. #if 0
  678.         yl = yoffset * t->ymax + (key_rows) * key_entry_height + (ktitle_lines + 2) * t->v_char;
  679.         xl = max_ptitl_len * 1000 / (key_sample_width / (t->h_char) + max_ptitl_len + 2);
  680.         xl *= (xright - xleft) / key_cols;
  681.         xl /= 1000;
  682.         xl += xleft;
  683. #else
  684.         /* HBB 19990608: why calculate these again? boundary3d has already 
  685.          * done it... */
  686.         if (ptitl_cnt > 0) {
  687.         /* maximise no cols, limited by label-length */
  688.         key_cols = (int) (xright - xleft) / key_col_wth;
  689.         key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
  690.         /* now calculate actual no cols depending on no rows */
  691.         key_cols = (int) (ptitl_cnt + key_rows - 1) / key_rows;
  692.         key_col_wth = (int) (xright - xleft) / key_cols;
  693.         /* we divide into columns, then centre in column by considering
  694.          * ratio of key_left_size to key_right_size
  695.          * key_size_left/(key_size_left+key_size_right) * (xright-xleft)/key_cols
  696.          * do one integer division to maximise accuracy (hope we dont
  697.          * overflow !)
  698.          */
  699.         xl = xleft + ((xright - xleft) * key_size_left) / (key_cols * (key_size_left + key_size_right));
  700.         yl = yoffset * t->ymax + (key_rows) * key_entry_height + (ktitle_lines + 2) * t->v_char;
  701.         }
  702. #endif
  703.     } else {
  704.         if (key_vpos == TTOP) {
  705.         yl = ytop - (t->v_tic) - t->v_char;
  706.         } else {
  707.         yl = ybot + (t->v_tic) + key_entry_height * key_rows + ktitle_lines * t->v_char;
  708.         }
  709.         if (key_hpos == TOUT) {
  710.         /* keys outside plot border (right) */
  711.         xl = xright + (t->h_tic) + key_size_left;
  712.         } else if (key_hpos == TLEFT) {
  713.         xl = xleft + (t->h_tic) + key_size_left;
  714.         } else {
  715.         xl = xright - key_size_right - key_col_wth * (key_cols - 1);
  716.         }
  717.     }
  718.     yl_ref = yl - ktitle_lines * (t->v_char);
  719.     }
  720.     if (key == 1) {
  721.     map_position(&key_user_pos, &xl, &yl, "key");
  722.     }
  723.     if (key && key_box.l_type > -3) {
  724.     int yt = yl;
  725.     int yb = yl - key_entry_height * (key_rows - ktitle_lines) - ktitle_lines * t->v_char;
  726.     int key_xr = xl + key_col_wth * (key_cols - 1) + key_size_right;
  727.     /* key_rows seems to contain title at this point ??? */
  728.     term_apply_lp_properties(&key_box);
  729.     (*t->move) (xl - key_size_left, yb);
  730.     (*t->vector) (xl - key_size_left, yt);
  731.     (*t->vector) (key_xr, yt);
  732.     (*t->vector) (key_xr, yb);
  733.     (*t->vector) (xl - key_size_left, yb);
  734.  
  735.     /* draw a horizontal line between key title and first entry  JFi */
  736.     (*t->move) (xl - key_size_left, yt - (ktitle_lines) * t->v_char);
  737.     (*t->vector) (xl + key_size_right, yt - (ktitle_lines) * t->v_char);
  738.     }
  739.     /* DRAW SURFACES AND CONTOURS */
  740.  
  741. #ifndef LITE
  742.     if (hidden3d && draw_surface)
  743.     plot3d_hidden(plots, pcount);
  744. #endif /* not LITE */
  745.  
  746.     /* KEY TITLE */
  747.     if (key != 0 && strlen(key_title)) {
  748.     char *ss = gp_alloc(strlen(key_title) + 2, "tmp string ss");
  749.     strcpy(ss, key_title);
  750.     strcat(ss, "\n");
  751.     s = ss;
  752.     yl -= t->v_char / 2;
  753.     while ((e = (char *) strchr(s, '\n')) != NULL) {
  754.         *e = '\0';
  755.         if (key_just == JLEFT) {
  756.         (*t->justify_text) (LEFT);
  757.         (*t->put_text) (xl + key_text_left, yl, s);
  758.         } else {
  759.         if ((*t->justify_text) (RIGHT)) {
  760.             (*t->put_text) (xl + key_text_right,
  761.                     yl, s);
  762.         } else {
  763.             int x = xl + key_text_right - (t->h_char) * strlen(s);
  764.             if (inrange(x, xleft, xright))
  765.             (*t->put_text) (x, yl, s);
  766.         }
  767.         }
  768.         s = ++e;
  769.         yl -= t->v_char;
  770.     }
  771.     yl += t->v_char / 2;
  772.     free(ss);
  773.     }
  774.     key_count = 0;
  775.     yl_ref = yl -= key_entry_height / 2;    /* centralise the keys */
  776.  
  777. #define NEXT_KEY_LINE() \
  778.  if ( ++key_count >= key_rows ) { \
  779.    yl = yl_ref; xl += key_col_wth; key_count = 0; \
  780.  } else \
  781.    yl -= key_entry_height
  782.  
  783.     this_plot = plots;
  784.     for (surface = 0;
  785.      surface < pcount;
  786.      this_plot = this_plot->next_sp, surface++) {
  787.  
  788. #ifndef LITE
  789.     if (hidden3d)
  790.         hidden_no_update = FALSE;
  791. #endif /* not LITE */
  792.  
  793.     if (draw_surface) {
  794.         int lkey = (key != 0 && this_plot->title && this_plot->title[0]);
  795.         term_apply_lp_properties(&(this_plot->lp_properties));
  796.  
  797. #ifndef LITE
  798.         if (hidden3d) {
  799.         hidden_line_type_above = this_plot->lp_properties.l_type;
  800.         hidden_line_type_below = this_plot->lp_properties.l_type + 1;
  801.         }
  802. #endif /* not LITE */
  803.  
  804.         if (lkey) {
  805.         key_text(xl, yl, this_plot->title);
  806.         }
  807.         switch (this_plot->plot_style) {
  808.         case BOXES:    /* can't do boxes in 3d yet so use impulses */
  809.         case IMPULSES:{
  810.             if (lkey) {
  811.             key_sample_line(xl, yl);
  812.             }
  813.             if (!(hidden3d && draw_surface))
  814.             plot3d_impulses(this_plot);
  815.             break;
  816.         }
  817.         case STEPS:    /* HBB: I think these should be here */
  818.         case FSTEPS:
  819.         case HISTEPS:
  820.         case LINES:{
  821.             if (lkey) {
  822.             key_sample_line(xl, yl);
  823.             }
  824.             if (!(hidden3d && draw_surface))
  825.             plot3d_lines(this_plot);
  826.             break;
  827.         }
  828.         case YERRORBARS:    /* ignored; treat like points */
  829.         case XERRORBARS:    /* ignored; treat like points */
  830.         case XYERRORBARS:    /* ignored; treat like points */
  831.         case BOXXYERROR:    /* HBB: ignore these as well */
  832.         case BOXERROR:
  833.         case CANDLESTICKS:    /* HBB: dito */
  834.         case FINANCEBARS:
  835.         case VECTOR:
  836.         case POINTSTYLE:
  837.         if (lkey && !clip_point(xl + key_point_offset, yl)) {
  838.             key_sample_point(xl, yl, this_plot->lp_properties.p_type);
  839.         }
  840.         if (!(hidden3d && draw_surface))
  841.             plot3d_points(this_plot);
  842.         break;
  843.  
  844.         case LINESPOINTS:
  845.         /* put lines */
  846.         if (lkey)
  847.             key_sample_line(xl, yl);
  848.  
  849.         if (!(hidden3d && draw_surface))
  850.             plot3d_lines(this_plot);
  851.  
  852.         /* put points */
  853.         if (lkey && !clip_point(xl + key_point_offset, yl))
  854.             key_sample_point(xl, yl, this_plot->lp_properties.p_type);
  855.  
  856.         if (!(hidden3d && draw_surface))
  857.             plot3d_points(this_plot);
  858.  
  859.         break;
  860.  
  861.         case DOTS:
  862.         if (lkey) {
  863.             if (key == 1) {
  864.             if (!clip_point(xl + key_point_offset, yl))
  865.                 (*t->point) (xl + key_point_offset, yl, -1);
  866.             } else {
  867.             (*t->point) (xl + key_point_offset, yl, -1);
  868.             /* (*t->point)(xl+2*(t->h_char),yl, -1); */
  869.             }
  870.         }
  871.         if (!(hidden3d && draw_surface))
  872.             plot3d_dots(this_plot);
  873.  
  874.         break;
  875.  
  876.  
  877.         }            /* switch(plot-style) */
  878.  
  879.         /* move key on a line */
  880.         if (lkey) {
  881.         NEXT_KEY_LINE();
  882.         }
  883.     }            /* draw_surface */
  884.  
  885. #ifndef LITE 
  886.     if (hidden3d) {
  887.         hidden_no_update = TRUE;
  888.         hidden_line_type_above = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
  889.         hidden_line_type_below = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
  890.     }
  891. #endif /* not LITE */
  892.  
  893.     if (draw_contour && this_plot->contours != NULL) {
  894.         struct gnuplot_contours *cntrs = this_plot->contours;
  895.  
  896.         term_apply_lp_properties(&(this_plot->lp_properties));
  897.         (*t->linetype) (this_plot->lp_properties.l_type + (hidden3d ? 2 : 1));
  898.  
  899.         if (key != 0 && this_plot->title && this_plot->title[0]
  900.         && !draw_surface && !label_contours) {
  901.         /* unlabelled contours but no surface : put key entry in now */
  902.         key_text(xl, yl, this_plot->title);
  903.  
  904.         switch (this_plot->plot_style) {
  905.         case IMPULSES:
  906.         case LINES:
  907.         case BOXES:    /* HBB: I think these should be here... */
  908.         case STEPS:
  909.         case FSTEPS:
  910.         case HISTEPS:
  911.             key_sample_line(xl, yl);
  912.             break;
  913.         case YERRORBARS:    /* ignored; treat like points */
  914.         case XERRORBARS:    /* ignored; treat like points */
  915.         case XYERRORBARS:    /* ignored; treat like points */
  916.         case BOXERROR:    /* HBB: ignore these as well */
  917.         case BOXXYERROR:
  918.         case CANDLESTICKS:    /* HBB: dito */
  919.         case FINANCEBARS:
  920.         case VECTOR:
  921.         case POINTSTYLE:
  922.             key_sample_point(xl, yl, this_plot->lp_properties.p_type);
  923.             break;
  924.         case LINESPOINTS:
  925.             key_sample_line(xl, yl);
  926.             break;
  927.         case DOTS:
  928.             key_sample_point(xl, yl, -1);
  929.             break;
  930.         }
  931.         NEXT_KEY_LINE();
  932.         }
  933.         linetypeOffset = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
  934.         while (cntrs) {
  935.         if (label_contours && cntrs->isNewLevel) {
  936.             (*t->linetype) (linetypeOffset++);
  937.             if (key) {
  938.  
  939. #ifndef LITE
  940.             if (hidden3d)
  941.                 hidden_line_type_below = hidden_line_type_above = linetypeOffset - 1;
  942. #endif /* not LITE */
  943.  
  944.             key_text(xl, yl, cntrs->label);
  945.  
  946.             switch (this_plot->plot_style) {
  947.             case IMPULSES:
  948.             case LINES:
  949.             case LINESPOINTS:
  950.             case BOXES:    /* HBB: these should be treated as well... */
  951.             case STEPS:
  952.             case FSTEPS:
  953.             case HISTEPS:
  954.                 key_sample_line(xl, yl);
  955.                 break;
  956.             case YERRORBARS:    /* ignored; treat like points */
  957.             case XERRORBARS:    /* ignored; treat like points */
  958.             case XYERRORBARS:    /* ignored; treat like points */
  959.             case BOXERROR:        /* HBB: treat these likewise */
  960.             case BOXXYERROR:
  961.             case CANDLESTICKS:    /* HBB: dito */
  962.             case FINANCEBARS:
  963.             case VECTOR:
  964.             case POINTSTYLE:
  965.                 key_sample_point(xl, yl, this_plot->lp_properties.p_type);
  966.                 break;
  967.             case DOTS:
  968.                 key_sample_point(xl, yl, -1);
  969.                 break;
  970.             }    /* switch */
  971.  
  972.             NEXT_KEY_LINE();
  973.  
  974.             }        /* key */
  975.         }        /* label_contours */
  976.         /* now draw the contour */
  977.         switch (this_plot->plot_style) {
  978.         case IMPULSES:
  979.         case BOXES:    /* HBB: this should also be treated somehow */
  980.             cntr3d_impulses(cntrs, this_plot);
  981.             break;
  982.         case LINES:
  983.         case STEPS:    /* HBB: these should also be handled, I think */
  984.         case FSTEPS:
  985.         case HISTEPS:
  986.             cntr3d_lines(cntrs);
  987.             break;
  988.         case YERRORBARS:    /* ignored; treat like points */
  989.         case XERRORBARS:    /* ignored; treat like points */
  990.         case XYERRORBARS:    /* ignored; treat like points */
  991.         case BOXERROR:    /* HBB: ignore these too... */
  992.         case BOXXYERROR:
  993.         case CANDLESTICKS:    /* HBB: dito */
  994.         case FINANCEBARS:
  995.         case VECTOR:
  996.         case POINTSTYLE:
  997.             cntr3d_points(cntrs, this_plot);
  998.             break;
  999.         case LINESPOINTS:
  1000.             cntr3d_lines(cntrs);
  1001.             cntr3d_points(cntrs, this_plot);
  1002.             break;
  1003.         case DOTS:
  1004.             cntr3d_dots(cntrs);
  1005.             break;
  1006.         }        /*switch */
  1007.  
  1008.         cntrs = cntrs->next;
  1009.         }            /* loop over contours */
  1010.     }            /* draw contours */
  1011.     }                /* loop over surfaces */
  1012.  
  1013.     draw_bottom_grid(plots, pcount);
  1014.  
  1015.     term_end_plot();
  1016.  
  1017. #ifndef LITE
  1018.     if (hidden3d && draw_surface) {
  1019.     term_hidden_line_removal();
  1020.     hidden_active = FALSE;
  1021.     }
  1022. #endif /* not LITE */
  1023.  
  1024. }
  1025.  
  1026. /* plot3d_impulses:
  1027.  * Plot the surfaces in IMPULSES style
  1028.  */
  1029. static void plot3d_impulses(plot)
  1030. struct surface_points *plot;
  1031. {
  1032.     int i;            /* point index */
  1033.     unsigned int x, y, x0, y0;    /* point in terminal coordinates */
  1034.     struct iso_curve *icrvs = plot->iso_crvs;
  1035.  
  1036.     while (icrvs) {
  1037.     struct coordinate GPHUGE *points = icrvs->points;
  1038.  
  1039.     for (i = 0; i < icrvs->p_count; i++) {0h Â”
  1040. èH9¤ints[i].type) {
  1041.         case INRANGE:
  1042.         {
  1043.             map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  1044.  
  1045.             if (inrange(0.0, min3d_z, max3d_z)) {
  1046.             map3d_xy(points[i].x, points[i].y, 0.0, &x0, &y0);
  1047.             } else if (inrange(min3d_z, 0.0, points[i].z)) {
  1048.             map3d_xy(points[i].x, points[i].y, min3d_z, &x0, &y0);
  1049.             } else {
  1050.             map3d_xy(points[i].x, points[i].y, max3d_z, &x0, &y0);
  1051.             }
  1052.  
  1053.             clip_move(x0, y0);
  1054.             clip_vector(x, y);
  1055.  
  1056.             break;
  1057.         }
  1058.         case OUTRANGE:
  1059.         {
  1060.             if (!inrange(points[i].x, x_min3d, x_max3d) ||
  1061.             !inrange(points[i].y, y_min3d, y_max3d))
  1062.             break;
  1063.  
  1064.             if (inrange(0.0, min3d_z, max3d_z)) {
  1065.             /* zero point is INRANGE */
  1066.             map3d_xy(points[i].x, points[i].y, 0.0, &x0, &y0);
  1067.  
  1068.             /* must cross z = min3d_z or max3d_z limits */
  1069.             if (inrange(min3d_z, 0.0, points[i].z) &&
  1070.                 min3d_z != 0.0 && min3d_z != points[i].z) {
  1071.                 map3d_xy(points[i].x, points[i].y, min3d_z, &x, &y);
  1072.             } else {
  1073.                 map3d_xy(points[i].x, points[i].y, max3d_z, &x, &y);
  1074.             }
  1075.             } else {
  1076.             /* zero point is also OUTRANGE */
  1077.             if (inrange(min3d_z, 0.0, points[i].z) &&
  1078.                 inrange(max3d_z, 0.0, points[i].z)) {
  1079.                 /* crosses z = min3d_z or max3d_z limits */
  1080.                 map3d_xy(points[i].x, points[i].y, max3d_z, &x, &y);
  1081.                 map3d_xy(points[i].x, points[i].y, min3d_z, &x0, &y0);
  1082.             } else {
  1083.                 /* doesn't cross z = min3d_z or max3d_z limits */
  1084.                 break;
  1085.             }
  1086.             }
  1087.  
  1088.             clip_move(x0, y0);
  1089.             clip_vector(x, y);
  1090.  
  1091.             break;
  1092.         }
  1093.         default:        /* just a safety */
  1094.         case UNDEFINED:{
  1095.             break;
  1096.         }
  1097.         }
  1098.     }
  1099.  
  1100.     icrvs = icrvs->next;
  1101.     }
  1102. }
  1103.  
  1104. /* plot3d_lines:
  1105.  * Plot the surfaces in LINES style
  1106.  */
  1107. /* We want to always draw the lines in the same direction, otherwise when
  1108.    we draw an adjacent box we might get the line drawn a little differently
  1109.    and we get splotches.  */
  1110.  
  1111. static void plot3d_lines(plot)
  1112. struct surface_points *plot;
  1113. {
  1114.     int i;
  1115.     unsigned int x, y, x0, y0;    /* point in terminal coordinates */
  1116.     double clip_x, clip_y, clip_z;
  1117.     struct iso_curve *icrvs = plot->iso_crvs;
  1118.     struct coordinate GPHUGE *points;
  1119.     enum coord_type prev = UNDEFINED;
  1120.     double lx[2], ly[2], lz[2];    /* two edge points */
  1121.  
  1122. #ifndef LITE
  1123. /* These are handled elsewhere.  */
  1124.     if (plot->has_grid_topology && hidden3d)
  1125.     return;
  1126. #endif /* not LITE */
  1127.  
  1128.     while (icrvs) {
  1129.     prev = UNDEFINED;    /* type of previous plot */
  1130.  
  1131.     for (i = 0, points = icrvs->points; i < icrvs->p_count; i++) {
  1132.         switch (points[i].type) {
  1133.         case INRANGE:{
  1134.             map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  1135.  
  1136.             if (prev == INRANGE) {
  1137.             clip_vector(x, y);
  1138.             } else {
  1139.             if (prev == OUTRANGE) {
  1140.                 /* from outrange to inrange */
  1141.                 if (!clip_lines1) {
  1142.                 clip_move(x, y);
  1143.                 } else {
  1144.                 /*
  1145.                  * Calculate intersection point and draw
  1146.                  * vector from there
  1147.                  */
  1148.                 edge3d_intersect(points, i, &clip_x, &clip_y, &clip_z);
  1149.  
  1150.                 map3d_xy(clip_x, clip_y, clip_z, &x0, &y0);
  1151.  
  1152.                 clip_move(x0, y0);
  1153.                 clip_vector(x, y);
  1154.                 }
  1155.             } else {
  1156.                 clip_move(x, y);
  1157.             }
  1158.             }
  1159.  
  1160.             break;
  1161.         }
  1162.         case OUTRANGE:{
  1163.             if (prev == INRANGE) {
  1164.             /* from inrange to outrange */
  1165.             if (clip_lines1) {
  1166.                 /*
  1167.                  * Calculate intersection point and draw
  1168.                  * vector to it
  1169.                  */
  1170.  
  1171.                 edge3d_intersect(points, i, &clip_x, &clip_y, &clip_z);
  1172.  
  1173.                 map3d_xy(clip_x, clip_y, clip_z, &x0, &y0);
  1174.  
  1175.                 clip_vector(x0, y0);
  1176.             }
  1177.             } else if (prev == OUTRANGE) {
  1178.             /* from outrange to outrange */
  1179.             if (clip_lines2) {
  1180.                 /*
  1181.                  * Calculate the two 3D intersection points
  1182.                  * if present
  1183.                  */
  1184.                 if (two_edge3d_intersect(points, i, lx, ly, lz)) {
  1185.  
  1186.                 map3d_xy(lx[0], ly[0], lz[0], &x, &y);
  1187.  
  1188.                 map3d_xy(lx[1], ly[1], lz[1], &x0, &y0);
  1189.  
  1190.                 clip_move(x, y);
  1191.                 clip_vector(x0, y0);
  1192.                 }
  1193.             }
  1194.             }
  1195.             break;
  1196.         }
  1197.         case UNDEFINED:{
  1198.             break;
  1199.         default:
  1200.             graph_error("Unknown point type in plot3d_lines");
  1201.         }
  1202.         }
  1203.  
  1204.         prev = points[i].type;
  1205.     }
  1206.  
  1207.     icrvs = icrvs->next;
  1208.     }
  1209. }
  1210.  
  1211. /* plot3d_points:
  1212.  * Plot the surfaces in POINTSTYLE style
  1213.  */
  1214. static void plot3d_points(plot)
  1215. struct surface_points *plot;
  1216. {
  1217.     int i;
  1218.     unsigned int x, y;
  1219.     struct termentry *t = term;
  1220.     struct iso_curve *icrvs = plot->iso_crvs;
  1221.  
  1222.     while (icrvs) {
  1223.     struct coordinate GPHUGE *points = icrvs->points;
  1224.  
  1225.     for (i = 0; i < icrvs->p_count; i++) {
  1226.         if (points[i].type == INRANGE) {
  1227.         map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  1228.  
  1229.         if (!clip_point(x, y))
  1230.             (*t->point) (x, y, plot->lp_properties.p_type);
  1231.         }
  1232.     }
  1233.  
  1234.     icrvs = icrvs->next;
  1235.     }
  1236. }
  1237.  
  1238. /* plot3d_dots:
  1239.  * Plot the surfaces in DOTS style
  1240.  */
  1241. static void plot3d_dots(plot)
  1242. struct surface_points *plot;
  1243. {
  1244.     int i;
  1245.     struct termentry *t = term;
  1246.     struct iso_curve *icrvs = plot->iso_crvs;
  1247.  
  1248.     while (icrvs) {
  1249.     struct coordinate GPHUGE *points = icrvs->points;
  1250.  
  1251.     for (i = 0; i < icrvs->p_count; i++) {
  1252.         if (points[i].type == INRANGE) {
  1253.         unsigned int x, y;
  1254.         map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  1255.  
  1256.         if (!clip_point(x, y))
  1257.             (*t->point) (x, y, -1);
  1258.         }
  1259.     }
  1260.  
  1261.     icrvs = icrvs->next;
  1262.     }
  1263. }
  1264.  
  1265. /* cntr3d_impulses:
  1266.  * Plot a surface contour in IMPULSES style
  1267.  */
  1268. static void cntr3d_impulses(cntr, plot)
  1269. struct gnuplot_contours *cntr;
  1270. struct surface_points *plot;
  1271. {
  1272.     int i;            /* point index */
  1273.     unsigned int x, y, x0, y0;    /* point in terminal coordinates */
  1274.  
  1275.     if (draw_contour & CONTOUR_SRF) {
  1276.     for (i = 0; i < cntr->num_pts; i++) {
  1277.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z,
  1278.              &x, &y);
  1279.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
  1280.              &x0, &y0);
  1281.  
  1282.         clip_move(x0, y0);
  1283.         clip_vector(x, y);
  1284.     }
  1285.     } else {
  1286.     /* Must be on base grid, so do points. */
  1287.     cntr3d_points(cntr, plot);
  1288.     }
  1289. }
  1290.  
  1291. /* cntr3d_lines:
  1292.  * Plot a surface contour in LINES style
  1293.  */
  1294. static void cntr3d_lines(cntr)
  1295. struct gnuplot_contours *cntr;
  1296. {
  1297.     int i;            /* point index */
  1298.     unsigned int x, y;        /* point in terminal coordinates */
  1299.  
  1300.     if (draw_contour & CONTOUR_SRF) {
  1301.     for (i = 0; i < cntr->num_pts; i++) {
  1302.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z,
  1303.              &x, &y);
  1304.  
  1305.         if (i > 0) {
  1306.         clip_vector(x, y);
  1307.         if (i == 1)
  1308.             suppressMove = TRUE;
  1309.         } else {
  1310.         clip_move(x, y);
  1311.         }
  1312.     }
  1313.     }
  1314.     /* beginning a new contour level, so moveto() required */
  1315.     suppressMove = FALSE;
  1316.  
  1317.     if (draw_contour & CONTOUR_BASE) {
  1318.     for (i = 0; i < cntr->num_pts; i++) {
  1319.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
  1320.              &x, &y);
  1321.  
  1322.         if (i > 0) {
  1323.         clip_vector(x, y);
  1324.         if (i == 1)
  1325.             suppressMove = TRUE;
  1326.         } else {
  1327.         clip_move(x, y);
  1328.         }
  1329.     }
  1330.     }
  1331.     /* beginning a new contour level, so moveto() required */
  1332.     suppressMove = FALSE;
  1333. }
  1334.  
  1335. /* cntr3d_points:
  1336.  * Plot a surface contour in POINTSTYLE style
  1337.  */
  1338. static void cntr3d_points(cntr, plot)
  1339. struct gnuplot_contours *cntr;
  1340. struct surface_points *plot;
  1341. {
  1342.     int i;
  1343.     unsigned int x, y;
  1344.     struct termentry *t = term;
  1345.  
  1346.     if (draw_contour & CONTOUR_SRF) {
  1347.     for (i = 0; i < cntr->num_pts; i++) {
  1348.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z, &x, &y);
  1349.  
  1350.         if (!clip_point(x, y))
  1351.         (*t->point) (x, y, plot->lp_properties.p_type);
  1352.     }
  1353.     }
  1354.     if (draw_contour & CONTOUR_BASE) {
  1355.     for (i = 0; i < cntr->num_pts; i++) {
  1356.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
  1357.              &x, &y);
  1358.  
  1359.         if (!clip_point(x, y))
  1360.         (*t->point) (x, y, plot->lp_properties.p_type);
  1361.     }
  1362.     }
  1363. }
  1364.  
  1365. /* cntr3d_dots:
  1366.  * Plot a surface contour in DOTS style
  1367.  */
  1368. static void cntr3d_dots(cntr)
  1369. struct gnuplot_contours *cntr;
  1370. {
  1371.     int i;
  1372.     unsigned int x, y;
  1373.     struct termentry *t = term;
  1374.  
  1375.     if (draw_contour & CONTOUR_SRF) {
  1376.     for (i = 0; i < cntr->num_pts; i++) {
  1377.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z, &x, &y);
  1378.  
  1379.         if (!clip_point(x, y))
  1380.         (*t->point) (x, y, -1);
  1381.     }
  1382.     }
  1383.     if (draw_contour & CONTOUR_BASE) {
  1384.     for (i = 0; i < cntr->num_pts; i++) {
  1385.         map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
  1386.              &x, &y);
  1387.  
  1388.         if (!clip_point(x, y))
  1389.         (*t->point) (x, y, -1);
  1390.     }
  1391.     }
  1392. }
  1393.  
  1394.  
  1395.  
  1396. /* map xmin | xmax to 0 | 1 and same for y
  1397.  * 0.1 avoids any rounding errors
  1398.  */
  1399. #define MAP_HEIGHT_X(x) ( (int) (((x)-x_min3d)/(x_max3d-x_min3d)+0.1) )
  1400. #define MAP_HEIGHT_Y(y) ( (int) (((y)-y_min3d)/(y_max3d-y_min3d)+0.1) )
  1401.  
  1402. /* if point is at corner, update height[][] and depth[][]
  1403.  * we are still assuming that extremes of surfaces are at corners,
  1404.  * but we are not assuming order of corners
  1405.  */
  1406. static void check_corner_height(p, height, depth)
  1407. struct coordinate GPHUGE *p;
  1408. double height[2][2];
  1409. double depth[2][2];
  1410. {
  1411.     if (p->type != INRANGE)
  1412.     return;
  1413.     if ((fabs(p->x - x_min3d) < zero || fabs(p->x - x_max3d) < zero) &&
  1414.     (fabs(p->y - y_min3d) < zero || fabs(p->y - y_max3d) < zero)) {
  1415.     unsigned int x = MAP_HEIGHT_X(p->x);
  1416.     unsigned int y = MAP_HEIGHT_Y(p->y);
  1417.     if (height[x][y] < p->z)
  1418.         height[x][y] = p->z;
  1419.     if (depth[x][y] > p->z)
  1420.         depth[x][y] = p->z;
  1421.     }
  1422. }
  1423.  
  1424.  
  1425. /* Draw the bottom grid that hold the tic marks for 3d surface. */
  1426. static void draw_bottom_grid(plot, plot_num)
  1427. struct surface_points *plot;
  1428. int plot_num;
  1429. {
  1430.     unsigned int x, y;        /* point in terminal coordinates */
  1431.     struct termentry *t = term;
  1432.     char ss[MAX_LINE_LEN+1];
  1433.  
  1434.     /* work out where the axes and tics are drawn */
  1435.  
  1436.     {
  1437.     int quadrant = surface_rot_z / 90;
  1438.     if ((quadrant + 1) & 2) {
  1439.         zaxis_x = x_max3d;
  1440.         xaxis_y = y_max3d;
  1441.     } else {
  1442.         zaxis_x = x_min3d;
  1443.         xaxis_y = y_min3d;
  1444.     }
  1445.  
  1446.     if (quadrant & 2) {
  1447.         zaxis_y = y_max3d;
  1448.         yaxis_x = x_min3d;
  1449.     } else {
  1450.         zaxis_y = y_min3d;
  1451.         yaxis_x = x_max3d;
  1452.     }
  1453.  
  1454.     if (surface_rot_x > 90) {
  1455.         /* labels on the back axes */
  1456.         back_x = yaxis_x = x_min3d + x_max3d - yaxis_x;
  1457.         back_y = xaxis_y = y_min3d + y_max3d - xaxis_y;
  1458.     } else {
  1459.         back_x = x_min3d + x_max3d - yaxis_x;
  1460.         back_y = y_min3d + y_max3d - xaxis_y;
  1461.     }
  1462.     }
  1463.  
  1464.     if (draw_border) {
  1465.     unsigned int bl_x, bl_y;    /* bottom left */
  1466.     unsigned int bb_x, bb_y;    /* bottom back */
  1467.     unsigned int br_x, br_y;    /* bottom right */
  1468.     unsigned int bf_x, bf_y;    /* bottom front */
  1469.  
  1470. #ifndef LITE
  1471.     int save_update = hidden_no_update;
  1472.     hidden_no_update = TRUE;
  1473. #endif /* LITE */
  1474.  
  1475.     /* Here is the one and only call to this function. */
  1476.     setlinestyle(border_lp);
  1477.  
  1478.     map3d_xy(zaxis_x, zaxis_y, base_z, &bl_x, &bl_y);
  1479.     map3d_xy(back_x, back_y, base_z, &bb_x, &bb_y);
  1480.     map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, base_z, &br_x, &br_y);
  1481.     map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, base_z, &bf_x, &bf_y);
  1482.  
  1483.     /* border around base */
  1484.     {
  1485.         int save = hidden_active;
  1486.         hidden_active = FALSE;    /* this is in front */
  1487.         if (draw_border & 4)
  1488.         draw_clip_line(br_x, br_y, bf_x, bf_y);
  1489.         if (draw_border & 1)
  1490.         draw_clip_line(bl_x, bl_y, bf_x, bf_y);
  1491.         hidden_active = save;
  1492.     }
  1493.     if (draw_border & 2)
  1494.         draw_clip_line(bl_x, bl_y, bb_x, bb_y);
  1495.     if (draw_border & 8)
  1496.         draw_clip_line(br_x, br_y, bb_x, bb_y);
  1497.  
  1498.     if (draw_surface || (draw_contour & CONTOUR_SRF)) {
  1499.         int save = hidden_active;
  1500.         /* map the 8 corners to screen */
  1501.         unsigned int fl_x, fl_y;    /* floor left */
  1502.         unsigned int fb_x, fb_y;    /* floor back */
  1503.         unsigned int fr_x, fr_y;    /* floor right */
  1504.         unsigned int ff_x, ff_y;    /* floor front */
  1505.  
  1506.         unsigned int tl_x, tl_y;    /* top left */
  1507.         unsigned int tb_x, tb_y;    /* top back */
  1508.         unsigned int tr_x, tr_y;    /* top right */
  1509.         unsigned int tf_x, tf_y;    /* top front */
  1510.  
  1511.         map3d_xy(zaxis_x, zaxis_y, floor_z, &fl_x, &fl_y);
  1512.         map3d_xy(back_x, back_y, floor_z, &fb_x, &fb_y);
  1513.         map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, floor_z, &fr_x, &fr_y);
  1514.         map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, floor_z, &ff_x, &ff_y);
  1515.  
  1516.         map3d_xy(zaxis_x, zaxis_y, ceiling_z, &tl_x, &tl_y);
  1517.         map3d_xy(back_x, back_y, ceiling_z, &tb_x, &tb_y);
  1518.         map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, ceiling_z, &tr_x, &tr_y);
  1519.         map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, ceiling_z, &tf_x, &tf_y);
  1520.  
  1521.         /* vertical lines, to surface or to very top */
  1522.         if ((draw_border & 0xf0) == 0xf0) {
  1523.         /* all four verticals drawn - save some time */
  1524.         draw_clip_line(fl_x, fl_y, tl_x, tl_y);
  1525.         draw_clip_line(fb_x, fb_y, tb_x, tb_y);
  1526.         draw_clip_line(fr_x, fr_y, tr_x, tr_y);
  1527.         hidden_active = FALSE;    /* this is in front */
  1528.         draw_clip_line(ff_x, ff_y, tf_x, tf_y);
  1529.         hidden_active = save;
  1530.         } else {
  1531.         /* search surfaces for heights at corners */
  1532.         double height[2][2];
  1533.         double depth[2][2];
  1534.         unsigned int zaxis_i = MAP_HEIGHT_X(zaxis_x);
  1535.         unsigned int zaxis_j = MAP_HEIGHT_Y(zaxis_y);
  1536.         unsigned int back_i = MAP_HEIGHT_X(back_x);
  1537.     /* HBB: why isn't back_j unsigned ??? */
  1538.         int back_j = MAP_HEIGHT_Y(back_y);
  1539.  
  1540.         height[0][0] = height[0][1] = height[1][0] = height[1][1] = base_z;
  1541.         depth[0][0] = depth[0][1] = depth[1][0] = depth[1][1] = base_z;
  1542.  
  1543.         for (; --plot_num >= 0; plot = plot->next_sp) {
  1544.             struct iso_curve *curve = plot->iso_crvs;
  1545.             int count = curve->p_count;
  1546.             int iso;
  1547.             if (plot->plot_type == DATA3D) {
  1548.             if (!plot->has_grid_topology)
  1549.                 continue;
  1550.             iso = plot->num_iso_read;
  1551.             } else
  1552.             iso = iso_samples_2;
  1553.  
  1554.             check_corner_height(curve->points, height, depth);
  1555.             check_corner_height(curve->points + count - 1, height, depth);
  1556.             while (--iso)
  1557.             curve = curve->next;
  1558.             check_corner_height(curve->points, height, depth);
  1559.             check_corner_height(curve->points + count - 1, height, depth);
  1560.         }
  1561.  
  1562. #define VERTICAL(mask,x,y,i,j,bx,by,tx,ty) \
  1563.  if (draw_border&mask) \
  1564.   draw_clip_line(bx,by,tx,ty);\
  1565. else if (height[i][j] != depth[i][j]) \
  1566. { unsigned int a0,b0, a1, b1; \
  1567.   map3d_xy(x,y,depth[i][j],&a0,&b0); \
  1568.   map3d_xy(x,y,height[i][j],&a1,&b1); \
  1569.   draw_clip_line(a0,b0,a1,b1); \
  1570. }
  1571.  
  1572.         VERTICAL(16,zaxis_x,zaxis_y,zaxis_i,zaxis_j,fl_x,fl_y,tl_x,tl_y);
  1573.         VERTICAL(32,back_x,back_y,back_i,back_j,fb_x,fb_y,tb_x,tb_y);
  1574.         VERTICAL(64,x_min3d+x_max3d-zaxis_x,y_min3d+y_max3d-zaxis_y,1-zaxis_i,1-zaxis_j,fr_x,fr_y,tr_x,tr_y);
  1575.         hidden_active = FALSE;
  1576.         VERTICAL(128,x_min3d+x_max3d-back_x,y_min3d+y_max3d-back_y,1-back_i,1-back_j,ff_x,ff_y,tf_x,tf_y);
  1577.             hidden_active = save;
  1578.         }
  1579.  
  1580.         /* now border lines on top */
  1581.         if (draw_border & 256)
  1582.         draw_clip_line(tl_x, tl_y, tb_x, tb_y);
  1583.         if (draw_border & 512)
  1584.         draw_clip_line(tr_x, tr_y, tb_x, tb_y);
  1585.         /* these lines are in front of surface (?) */
  1586.         hidden_active = FALSE;
  1587.         if (draw_border & 1024)
  1588.         draw_clip_line(tl_x, tl_y, tf_x, tf_y);
  1589.         if (draw_border & 2048)
  1590.         draw_clip_line(tr_x, tr_y, tf_x, tf_y);
  1591.         hidden_active = save;
  1592.     }
  1593.  
  1594. #ifndef LITE
  1595.     hidden_no_update = save_update;
  1596. #endif /* LITE */
  1597.  
  1598.     }
  1599.     if (xtics || *xlabel.text) {
  1600.     unsigned int x0, y0, x1, y1;
  1601.     double mid_x = (x_max3d + x_min3d) / 2;
  1602.     double len;
  1603.     map3d_xy(mid_x, xaxis_y, base_z, &x0, &y0);
  1604.     map3d_xy(mid_x, y_min3d + y_max3d - xaxis_y, base_z, &x1, &y1);
  1605.     {            /* take care over unsigned quantities */
  1606.         int dx = x1 - x0;
  1607.         int dy = y1 - y0;
  1608.         /* HBB 980309: 16bit strikes back: */
  1609.         len = sqrt(((double) dx) * dx + ((double) dy) * dy);
  1610.         if (len != 0) {
  1611.         tic_unitx = dx / len;
  1612.         tic_unity = dy / len;
  1613.         } else {
  1614.         tic_unitx = tic_unity = 0;
  1615.         }
  1616.     }
  1617.  
  1618.     if (xtics) {
  1619.         gen_tics(FIRST_X_AXIS, &xticdef,
  1620.              work_grid.l_type & (GRID_X | GRID_MX),
  1621.              mxtics, mxtfreq, xtick_callback);
  1622.     }
  1623.     if (*xlabel.text) {
  1624.         /* label at xaxis_y + 1/4 of (xaxis_y-other_y) */
  1625.         double step = (2 * xaxis_y - y_max3d - y_min3d) / 4;
  1626.         map3d_xy(mid_x, xaxis_y + step, base_z, &x1, &y1);
  1627.         x1 += xlabel.xoffset * t->h_char;
  1628.         y1 += xlabel.yoffset * t->v_char;
  1629.         if (!tic_in) {
  1630.         x1 -= tic_unitx * ticscale * (t->h_tic);
  1631.         y1 -= tic_unity * ticscale * (t->v_tic);
  1632.         }
  1633.         /* write_multiline mods it */
  1634.         write_multiline(x1, y1, xlabel.text, CENTRE, JUST_TOP, 0, xlabel.font);
  1635.     }
  1636.     }
  1637.     if (ytics || *ylabel.text) {
  1638.     unsigned int x0, y0, x1, y1;
  1639.     double mid_y = (y_max3d + y_min3d) / 2;
  1640.     double len;
  1641.     map3d_xy(yaxis_x, mid_y, base_z, &x0, &y0);
  1642.     map3d_xy(x_min3d + x_max3d - yaxis_x, mid_y, base_z, &x1, &y1);
  1643.     {            /* take care over unsigned quantities */
  1644.         int dx = x1 - x0;
  1645.         int dy = y1 - y0;
  1646.         /* HBB 980309: 16 Bits strike again: */
  1647.         len = sqrt(((double) dx) * dx + ((double) dy) * dy);
  1648.         if (len != 0) {
  1649.         tic_unitx = dx / len;
  1650.         tic_unity = dy / len;
  1651.         } else {
  1652.         tic_unitx = tic_unity = 0;
  1653.         }
  1654.     }
  1655.     if (ytics) {
  1656.         gen_tics(FIRST_Y_AXIS, &yticdef,
  1657.              work_grid.l_type & (GRID_Y | GRID_MY),
  1658.              mytics, mytfreq, ytick_callback);
  1659.     }
  1660.     if (*ylabel.text) {
  1661.         double step = (x_max3d + x_min3d - 2 * yaxis_x) / 4;
  1662.         map3d_xy(yaxis_x - step, mid_y, base_z, &x1, &y1);
  1663.         x1 += ylabel.xoffset * t->h_char;
  1664.         y1 += ylabel.yoffset * t->v_char;
  1665.         if (!tic_in) {
  1666.         x1 -= tic_unitx * ticscale * (t->h_tic);
  1667.         y1 -= tic_unity * ticscale * (t->v_tic);
  1668.         }
  1669.         /* write_multiline mods it */
  1670.         safe_strncpy(ss, ylabel.text, sizeof(ss));
  1671.         write_multiline(x1, y1, ss, CENTRE, JUST_TOP, 0, ylabel.font);
  1672.     }
  1673.     }
  1674.     /* do z tics */
  1675.  
  1676.     if (ztics && (draw_surface || (draw_contour & CONTOUR_SRF))) {
  1677.     gen_tics(FIRST_Z_AXIS, &zticdef, work_grid.l_type & (GRID_Z | GRID_MZ),
  1678.          mztics, mztfreq, ztick_callback);
  1679.     }
  1680.     if ((yzeroaxis.l_type >= -2) && !is_log_x && inrange(0, x_min3d, x_max3d)) {
  1681.     unsigned int x, y, x1, y1;
  1682.     term_apply_lp_properties(&yzeroaxis);
  1683.     map3d_xy(0.0, y_min3d, base_z, &x, &y);        /* line through x=0 */
  1684.     map3d_xy(0.0, y_max3d, base_z, &x1, &y1);
  1685.     draw_clip_line(x, y, x1, y1);
  1686.     }
  1687.     if ((xzeroaxis.l_type >= -2) && !is_log_y && inrange(0, y_min3d, y_max3d)) {
  1688.     unsigned int x, y, x1, y1;
  1689.     term_apply_lp_properties(&xzeroaxis);
  1690.     map3d_xy(x_min3d, 0.0, base_z, &x, &y);        /* line through y=0 */
  1691.     map3d_xy(x_max3d, 0.0, base_z, &x1, &y1);
  1692.     draw_clip_line(x, y, x1, y1);
  1693.     }
  1694.     /* PLACE ZLABEL - along the middle grid Z axis - eh ? */
  1695.     if (*zlabel.text && (draw_surface || (draw_contour & CONTOUR_SRF))) {
  1696.     map3d_xy(zaxis_x, zaxis_y, z_max3d + (z_max3d - base_z) / 4, &x, &y);
  1697.  
  1698.     x += zlabel.xoffset * t->h_char;
  1699.     y += zlabel.yoffset * t->v_char;
  1700.  
  1701.     write_multiline(x, y, zlabel.text, CENTRE, CENTRE, 0, zlabel.font);
  1702.  
  1703.     }
  1704. }
  1705.  
  1706.  
  1707. static void xtick_callback(axis, place, text, grid)
  1708. int axis;
  1709. double place;
  1710. char *text;
  1711. struct lp_style_type grid;    /* linetype or -2 for none */
  1712. {
  1713.     unsigned int x, y, x1, y1;
  1714.     double scale = (text ? ticscale : miniticscale);
  1715.     int dirn = tic_in ? 1 : -1;
  1716.     register struct termentry *t = term;
  1717.  
  1718.     map3d_xy(place, xaxis_y, base_z, &x, &y);
  1719.     if (grid.l_type > -2) {
  1720.     term_apply_lp_properties(&grid);
  1721.     /* to save mapping twice, map non-axis y */
  1722.     map3d_xy(place, y_min3d + y_max3d - xaxis_y, base_z, &x1, &y1);
  1723.     draw_clip_line(x, y, x1, y1);
  1724.     term_apply_lp_properties(&border_lp);
  1725.     }
  1726.     if (xtics & TICS_ON_AXIS) {
  1727.     map3d_xy(place, (y_min3d + y_max3d) / 2, base_z, &x, &y);
  1728.     }
  1729.     x1 = x + tic_unitx * scale * (t->h_tic) * dirn;
  1730.     y1 = y + tic_unity * scale * (t->v_tic) * dirn;
  1731.     draw_clip_line(x, y, x1, y1);
  1732.     if (text) {
  1733.     int just;
  1734.     if (tic_unitx < -0.9)
  1735.         just = LEFT;
  1736.     else if (tic_unitx < 0.9)
  1737.         just = CENTRE;
  1738.     else
  1739.         just = RIGHT;
  1740. #if 1
  1741. /* HBB 970729: let's see if the 'tic labels collide with axes' problem
  1742.  * may be fixed this way: */
  1743.     x1 = x - tic_unitx * (t->h_char) * 1;
  1744.     y1 = y - tic_unity * (t->v_char) * 1;
  1745. #else
  1746.     x1 = x - tic_unitx * (t->h_tic) * 2;
  1747.     y1 = y - tic_unity * (t->v_tic) * 2;
  1748. #endif
  1749.     if (!tic_in) {
  1750.         x1 -= tic_unitx * (t->h_tic) * ticscale;
  1751.         y1 -= tic_unity * (t->v_tic) * ticscale;
  1752.     }
  1753.     clip_put_text_just(x1, y1, text, just);
  1754.     }
  1755.     if (xtics & TICS_MIRROR) {
  1756.     map3d_xy(place, y_min3d + y_max3d - xaxis_y, base_z, &x, &y);
  1757.     x1 = x - tic_unitx * scale * (t->h_tic) * dirn;
  1758.     y1 = y - tic_unity * scale * (t->v_tic) * dirn;
  1759.     draw_clip_line(x, y, x1, y1);
  1760.     }
  1761. }
  1762.  
  1763. static void ytick_callback(axis, place, text, grid)
  1764. int axis;
  1765. double place;
  1766. char *text;
  1767. struct lp_style_type grid;
  1768. {
  1769.     unsigned int x, y, x1, y1;
  1770.     double scale = (text ? ticscale : miniticscale);
  1771.     int dirn = tic_in ? 1 : -1;
  1772.     register struct termentry *t = term;
  1773.  
  1774.     map3d_xy(yaxis_x, place, base_z, &x, &y);
  1775.     if (grid.l_type > -2) {
  1776.     term_apply_lp_properties(&grid);
  1777.     map3d_xy(x_min3d + x_max3d - yaxis_x, place, base_z, &x1, &y1);
  1778.     draw_clip_line(x, y, x1, y1);
  1779.     term_apply_lp_properties(&border_lp);
  1780.     }
  1781.     if (ytics & TICS_ON_AXIS) {
  1782.     map3d_xy((x_min3d + x_max3d) / 2, place, base_z, &x, &y);
  1783.     }
  1784.     x1 = x + tic_unitx * scale * dirn * (t->h_tic);
  1785.     y1 = y + tic_unity * scale * dirn * (t->v_tic);
  1786.     draw_clip_line(x, y, x1, y1);
  1787.     if (text) {
  1788.     int just;
  1789.     if (tic_unitx < -0.9)
  1790.         just = LEFT;
  1791.     else if (tic_unitx < 0.9)
  1792.         just = CENTRE;
  1793.     else
  1794.         just = RIGHT;
  1795. #if 1
  1796.     /* HBB 970729: same as above in xtics_callback */
  1797.     x1 = x - tic_unitx * (t->h_char) * 1;
  1798.     y1 = y - tic_unity * (t->v_char) * 1;
  1799. #else
  1800.     x1 = x - tic_unitx * (t->h_tic) * 2;
  1801.     y1 = y - tic_unity * (t->v_tic) * 2;
  1802. #endif
  1803.     if (!tic_in) {
  1804.         x1 -= tic_unitx * (t->h_tic) * ticscale;
  1805.         y1 -= tic_unity * (t->v_tic) * ticscale;
  1806.     }
  1807.     clip_put_text_just(x1, y1, text, just);
  1808.     }
  1809.     if (ytics & TICS_MIRROR) {
  1810.     map3d_xy(x_min3d + x_max3d - yaxis_x, place, base_z, &x, &y);
  1811.     x1 = x - tic_unitx * scale * (t->h_tic) * dirn;
  1812.     y1 = y - tic_unity * scale * (t->v_tic) * dirn;
  1813.     draw_clip_line(x, y, x1, y1);
  1814.     }
  1815. }
  1816.  
  1817. static void ztick_callback(axis, place, text, grid)
  1818. int axis;
  1819. double place;
  1820. char *text;
  1821. struct lp_style_type grid;
  1822. {
  1823. /* HBB: inserted some ()'s to shut up gcc -Wall, here and below */
  1824.     int len = (text ? ticscale : miniticscale) * (tic_in ? 1 : -1) * (term->h_tic);
  1825.     unsigned int x, y;
  1826.  
  1827.     if (grid.l_type > -2) {
  1828.     unsigned int x1, y1, x2, y2, x3, y3;
  1829.     double other_x = x_min3d + x_max3d - zaxis_x;
  1830.     double other_y = y_min3d + y_max3d - zaxis_y;
  1831.     term_apply_lp_properties(&grid);
  1832.     map3d_xy(zaxis_x, zaxis_y, place, &x1, &y1);
  1833.     map3d_xy(back_x, back_y, place, &x2, &y2);
  1834.     map3d_xy(other_x, other_y, place, &x3, &y3);
  1835.     draw_clip_line(x1, y1, x2, y2);
  1836.     draw_clip_line(x2, y2, x3, y3);
  1837.     term_apply_lp_properties(&border_lp);
  1838.     }
  1839.     map3d_xy(zaxis_x, zaxis_y, place, &x, &y);
  1840.     draw_clip_line(x, y, x + len, y);
  1841.     if (text) {
  1842.     int x1 = x - (term->h_tic) * 2;
  1843.     if (!tic_in)
  1844.         x1 -= (term->h_tic) * ticscale;
  1845.     clip_put_text_just(x1, y, text, RIGHT);
  1846.     }
  1847.     if (ztics & TICS_MIRROR) {
  1848.     double other_x = x_min3d + x_max3d - zaxis_x;
  1849.     double other_y = y_min3d + y_max3d - zaxis_y;
  1850.     map3d_xy(other_x, other_y, place, &x, &y);
  1851.     draw_clip_line(x, y, x - len, y);
  1852.     }
  1853. }
  1854.  
  1855.  
  1856. static void map_position(pos, x, y, what)
  1857. struct position *pos;
  1858. unsigned int *x, *y;
  1859. char *what;
  1860. {
  1861.     double xpos = pos->x;
  1862.     double ypos = pos->y;
  1863.     double zpos = pos->z;
  1864.     int screens = 0;        /* need either 0 or 3 screen co-ordinates */
  1865.  
  1866.     switch (pos->scalex) {
  1867.     case first_axes:
  1868.     case second_axes:
  1869.     xpos = LogScale(xpos, is_log_x, log_base_log_x, what, "x");
  1870.     break;
  1871.     case graph:
  1872.     xpos = min_array[FIRST_X_AXIS] +
  1873.         xpos * (max_array[FIRST_X_AXIS] - min_array[FIRST_X_AXIS]);
  1874.     break;
  1875.     case screen:
  1876.     ++screens;
  1877.     }
  1878.  
  1879.     switch (pos->scaley) {
  1880.     case first_axes:
  1881.     case second_axes:
  1882.     ypos = LogScale(ypos, is_log_y, log_base_log_y, what, "y");
  1883.     break;
  1884.     case graph:
  1885.     ypos = min_array[FIRST_Y_AXIS] +
  1886.         ypos * (max_array[FIRST_Y_AXIS] - min_array[FIRST_Y_AXIS]);
  1887.     break;
  1888.     case screen:
  1889.     ++screens;
  1890.     }
  1891.  
  1892.     switch (pos->scalez) {
  1893.     case first_axes:
  1894.     case second_axes:
  1895.     zpos = LogScale(zpos, is_log_z, log_base_log_z, what, "z");
  1896.     break;
  1897.     case graph:
  1898.     zpos = min_array[FIRST_Z_AXIS] +
  1899.         zpos * (max_array[FIRST_Z_AXIS] - min_array[FIRST_Z_AXIS]);
  1900.     break;
  1901.     case screen:
  1902.     ++screens;
  1903.     }
  1904.  
  1905.     if (screens == 0) {
  1906.     map3d_xy(xpos, ypos, zpos, x, y);
  1907.     return;
  1908.     }
  1909.     if (screens != 3) {
  1910.     graph_error("Cannot mix screen co-ordinates with other types");
  1911.     } {
  1912.     register struct termentry *t = term;
  1913.     *x = pos->x * (t->xmax) + 0.5;
  1914.     *y = pos->y * (t->ymax) + 0.5;
  1915.     }
  1916.  
  1917.     return;
  1918. }
  1919.  
  1920.  
  1921. /*
  1922.  * these code blocks were moved to functions, to make the code simpler
  1923.  */
  1924.  
  1925. static void key_text(xl, yl, text)
  1926. int xl, yl;
  1927. char *text;
  1928. {
  1929.     if (key_just == JLEFT && key == -1) {
  1930.     (*term->justify_text) (LEFT);
  1931.     (*term->put_text) (xl + key_text_left, yl, text);
  1932.     } else {
  1933.     if ((*term->justify_text) (RIGHT)) {
  1934.         if (key == 1)
  1935.         clip_put_text(xl + key_text_right, yl, text);
  1936.         else
  1937.         (*term->put_text) (xl + key_text_right, yl, text);
  1938.     } else {
  1939.         int x = xl + key_text_right - (term->h_char) * strlen(text);
  1940.         if (key == 1) {
  1941.         if (i_inrange(x, xleft, xright))
  1942.             clip_put_text(x, yl, text);
  1943.         } else {
  1944.         (*term->put_text) (x, yl, text);
  1945.         }
  1946.     }
  1947.     }
  1948. }
  1949.  
  1950. static void key_sample_line(xl, yl)
  1951. int xl, yl;
  1952. {
  1953.     if (key == -1) {
  1954.     (*term->move) (xl + key_sample_left, yl);
  1955.     (*term->vector) (xl + key_sample_right, yl);
  1956.     } else {
  1957.     /* HBB 981118: avoid crash if hidden3d sees a manually placed key:
  1958.      * simply turn off hidden-lining while we're drawing the key line: */
  1959.     int save_hidden_active = hidden_active;
  1960.     hidden_active = FALSE;
  1961.  
  1962.     clip_move(xl + key_sample_left, yl);
  1963.     clip_vector(xl + key_sample_right, yl);
  1964.     hidden_active = save_hidden_active;
  1965.     }
  1966. }
  1967.  
  1968. static void key_sample_point(xl, yl, pointtype)
  1969. int xl, yl;
  1970. int pointtype;
  1971. {
  1972.     if (!clip_point(xl + key_point_offset, yl)) {
  1973.     (*term->point) (xl + key_point_offset, yl, pointtype);
  1974.     } else {
  1975.     (*term->point) (xl + key_point_offset, yl, pointtype);
  1976.     }
  1977. }
  1978.